home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 43 / Amiga Format CD43 (1999)(Future Publishing)(GB)(Track 1 of 2)[!][issue 1999-09].iso / -serious- / sound / newmiditools / src / newmidiout.c < prev    next >
C/C++ Source or Header  |  1999-06-14  |  18KB  |  759 lines
  1. #ifndef MAKE_ID
  2. #define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
  3. #endif
  4.  
  5. //      NEW MIDI OUT TOOL
  6. //      BY G.O.Jones 1998
  7. //      -----------------
  8.  
  9. #include "bars.h"
  10. #include <clib/debug_protos.h>
  11. #include <clib/dos_protos.h>
  12. #include <libraries/dos.h>
  13. #include <devices/serial.h>
  14. #include <proto/exec.h>
  15. #include <proto/graphics.h>
  16. #include <proto/intuition.h>
  17. #include <exec/memory.h>
  18. #include <string.h>
  19. #include <intuition/intuition.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <ctype.h>
  23.  
  24. #define ID_MOU MAKE_ID('M','O','U','T')
  25. #define LEFT 7
  26. #define TOP  15
  27.  
  28. void removetool(struct OutTool *tool);
  29. void sendsysex(char *buff, short size);
  30. int openserial(char *devicename, int unit);
  31. void closeserial(void);
  32. struct Event *processeventcode(struct Event *event);
  33. static void deletetool(struct OutTool *copy);
  34.  
  35. extern struct Functions *functions;
  36. struct Task *task;
  37. BOOL serial = FALSE;
  38. char name[300];
  39. char un[300];
  40. int unit=0;
  41.  
  42. static struct MsgPort  *SerialMP;         /* Message port pointer */
  43. static struct IOExtSer *SerialIO;         /* I/O request pointer */
  44.  
  45. static UWORD chip outtool[]=
  46. {
  47. /*-------- plane # 0 --------*/
  48.  
  49.   0x0000,  0x0000,
  50.   0x3fff,  0xff00,
  51.   0x3000,  0x0300,
  52.   0x3000,  0x0300,
  53.   0x3000,  0x0300,
  54.   0x3000,  0x0300,
  55.   0x3100,  0x1300,
  56.   0x3040,  0x8300,
  57.   0x300c,  0x0300,
  58.   0x3000,  0x0300,
  59.   0x3fff,  0xff00,
  60.   0x0000,  0x0000,
  61.  
  62. /*-------- plane # 1 --------*/
  63.  
  64.   0x0000,  0x0000,
  65.   0x0000,  0x0300,
  66.   0x0f8c,  0x7f00,
  67.   0x0c0c,  0x0f00,
  68.   0xc800,  0x0700,
  69.   0xc000,  0x0300,
  70.   0xc000,  0x0300,
  71.   0xc800,  0x0700,
  72.   0x0c00,  0x0f00,
  73.   0x0f80,  0x7f00,
  74.   0x1fff,  0xff00,
  75.   0x0000,  0x0000,
  76.  
  77. /*-------- plane # 2 --------*/
  78.  
  79.   0x0000,  0x0000,
  80.   0x0000,  0x0000,
  81.   0x0073,  0x8000,
  82.   0x03f3,  0xf000,
  83.   0x07ff,  0xf800,
  84.   0x0fff,  0xfc00,
  85.   0x0eff,  0xec00,
  86.   0x07bf,  0x7800,
  87.   0x03f3,  0xf000,
  88.   0x007f,  0x8000,
  89.   0x0000,  0x0000,
  90.   0x0000,  0x0000
  91. };
  92.  
  93.  struct  Image outtoolimage =
  94.  {
  95.  0,0,
  96.  24 , 12 , 3 ,
  97.  outtool,
  98.  0x7,0x00,
  99.  NULL,
  100.  };
  101.  
  102. struct OutTool {
  103.                     struct Tool tool;
  104.                     BOOL Note;
  105.                     BOOL Pitch;
  106.                     BOOL MonoAT;
  107.                     BOOL PolyAT;
  108.                     BOOL CChange;
  109.                     BOOL PChange;
  110.                     BOOL SysEx;
  111.                };
  112.  
  113. extern struct Functions *functions;
  114.  
  115. // ----------------------------------------------
  116.  
  117. static struct IntuiText sysexgadText = {
  118.         4,0,JAM1,
  119.         2,1,
  120.         NULL,
  121.         "System Exclusive",
  122.         NULL
  123. };
  124.  
  125. static struct Gadget sysexgad = {
  126.         NULL,
  127.         LEFT,TOP+66,
  128.         130,9,
  129.         GADGHBOX+GADGHIMAGE,
  130.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  131.         BOOLGADGET,
  132.         NULL,
  133.         NULL,
  134.         &sysexgadText,
  135.         NULL,
  136.         NULL,
  137.         6,
  138.         NULL
  139. };
  140.  
  141. static struct IntuiText pchangegadText = {
  142.         4,0,JAM1,
  143.         12,1,
  144.         NULL,
  145.         "Program Change",
  146.         NULL
  147. };
  148.  
  149. static struct Gadget pchangegad = {
  150.         &sysexgad,
  151.         LEFT,TOP+55,
  152.         130,9,
  153.         GADGHBOX+GADGHIMAGE,
  154.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  155.         BOOLGADGET,
  156.         NULL,
  157.         NULL,
  158.         &pchangegadText,
  159.         NULL,
  160.         NULL,
  161.         5,
  162.         NULL
  163. };
  164.  
  165. static struct IntuiText cchangegadText = {
  166.         4,0,JAM1,
  167.         12,1,
  168.         NULL,
  169.         "Control Change",
  170.         NULL
  171. };
  172.  
  173. static struct Gadget cchangegad = {
  174.         &pchangegad,
  175.         LEFT,TOP+44,
  176.         130,9,
  177.         GADGHBOX+GADGHIMAGE,
  178.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  179.         BOOLGADGET,
  180.         NULL,
  181.         NULL,
  182.         &cchangegadText,
  183.         NULL,
  184.         NULL,
  185.         4,
  186.         NULL
  187. };
  188.  
  189. static struct IntuiText polyATgadText = {
  190.         4,0,JAM1,
  191.         5,1,
  192.         NULL,
  193.         "Poly Aftertouch",
  194.         NULL
  195. };
  196.  
  197. static struct Gadget polyATgad = {
  198.         &cchangegad,
  199.         LEFT,TOP+33,
  200.         130,9,
  201.         GADGHBOX+GADGHIMAGE,
  202.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  203.         BOOLGADGET,
  204.         NULL,
  205.         NULL,
  206.         &polyATgadText,
  207.         NULL,
  208.         NULL,
  209.         3,
  210.         NULL
  211. };
  212.  
  213. static struct IntuiText monoATgadText = {
  214.         4,0,JAM1,
  215.         5,1,
  216.         NULL,
  217.         "Mono Aftertouch",
  218.         NULL
  219. };
  220.  
  221. static struct Gadget monoATgad = {
  222.         &polyATgad,
  223.         LEFT,TOP+22,
  224.         130,9,
  225.         GADGHBOX+GADGHIMAGE,
  226.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  227.         BOOLGADGET,
  228.         NULL,
  229.         NULL,
  230.         &monoATgadText,
  231.         NULL,
  232.         NULL,
  233.         2,
  234.         NULL
  235. };
  236.  
  237. static struct IntuiText pitchgadText = {
  238.         4,0,JAM1,
  239.         23,1,
  240.         NULL,
  241.         "Pitch Wheel",
  242.         NULL
  243. };
  244.  
  245. static struct Gadget pitchgad = {
  246.         &monoATgad,
  247.         LEFT,TOP+11,
  248.         130,9,
  249.         GADGHBOX+GADGHIMAGE,
  250.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  251.         BOOLGADGET,
  252.         NULL,
  253.         NULL,
  254.         &pitchgadText,
  255.         NULL,
  256.         NULL,
  257.         1,
  258.         NULL
  259. };
  260.  
  261. static struct IntuiText notegadText = {
  262.         4,0,JAM1,
  263.         22,1,
  264.         NULL,
  265.         "Note On/Off",
  266.         NULL
  267. };
  268.  
  269. static struct Gadget notegad = {
  270.         &pitchgad,
  271.         LEFT,TOP,
  272.         130,9,
  273.         GADGHBOX+GADGHIMAGE,
  274.         RELVERIFY+GADGIMMEDIATE+TOGGLESELECT,
  275.         BOOLGADGET,
  276.         NULL,
  277.         NULL,
  278.         ¬egadText,
  279.         NULL,
  280.         NULL,
  281.         0,
  282.         NULL
  283. };
  284.  
  285. // ------------------------------------------------
  286.  
  287. #define GadgetList  notegad;
  288.  
  289. static struct NewWindow outNewWindowStructure1 = {
  290.         400,100,
  291.         145,95,
  292.         6,1,
  293.         GADGETDOWN+CLOSEWINDOW,
  294.         WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+ACTIVATE+NOCAREREFRESH,
  295.         ¬egad,
  296.         NULL,
  297.         "New MIDI Out 1",
  298.         NULL,
  299.         NULL,
  300.         5,5,
  301.         0,0,
  302.         CUSTOMSCREEN
  303. };
  304.  
  305. void setgadgettext(struct Window *window, short id, char *text)
  306. {
  307.     struct Gadget *gadget = (struct Gadget *) (*functions->GetGadget)(window,id);
  308.     if (gadget) {
  309.         gadget->GadgetText->IText = text;
  310.         (functions->DrawEmbossed)(window,id);
  311.     }
  312. }
  313.  
  314. void sendsysex(char *buff,short size)
  315. {
  316.             if(size>1500)
  317.             (*functions->transportcommand)(TC_STOP,functions->timenow);
  318.  
  319.             SerialIO->IOSer.io_Length=size;
  320.             SerialIO->IOSer.io_Data=(APTR)buff;
  321.             SerialIO->IOSer.io_Command=CMD_WRITE;
  322.             if(serial)
  323.             {
  324.                 DoIO((struct IORequest *)SerialIO);
  325.                 WaitTOF();
  326.             }
  327. }
  328.  
  329. void edittoolcode(struct OutTool *tool)
  330. {
  331.     struct IntuiMessage *message;
  332.     struct Window *window;
  333.     long class, code;
  334.     short refresh = 1;
  335.     struct Gadget *gadget;
  336.     struct NewWindow *newwindow;
  337.  
  338.     outNewWindowStructure1.Screen = functions->screen;
  339.     if (tool->tool.touched & TOUCH_EDIT) {
  340.         outNewWindowStructure1.LeftEdge = tool->tool.left;
  341.         outNewWindowStructure1.TopEdge = tool->tool.top;
  342.     }
  343.     if (!tool->tool.touched) {
  344.         tool->tool.touched = TOUCH_INIT;
  345.  
  346.                     tool->Note= TRUE;
  347.                     tool->Pitch= TRUE;
  348.                     tool->MonoAT= TRUE;
  349.                     tool->PolyAT= TRUE;
  350.                     tool->CChange= TRUE;
  351.                     tool->PChange= TRUE;
  352.                     tool->SysEx= FALSE;
  353.     }
  354.     newwindow = (struct NewWindow *)
  355.         (*functions->DupeNewWindow)(&outNewWindowStructure1);
  356.     if (!newwindow) return;
  357.     newwindow->Title = 0;
  358.     newwindow->Flags |= BORDERLESS;
  359.     newwindow->Flags &= ~0xF;
  360.     newwindow->DetailPen = 0;
  361.     newwindow->BlockPen = 0;
  362.     window = (struct Window *)
  363.         (*functions->FlashyOpenWindow)(newwindow);
  364.     if (!window) return;
  365.     tool->tool.window = window;
  366.     (*functions->EmbossWindowOn)(window,WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG,
  367.         "New Midi Out",(short)-1,(short)-1,0,0);
  368.  
  369.     (*functions->EmbossOn)(window,0,1);
  370.     (*functions->EmbossOn)(window,1,1);
  371.     (*functions->EmbossOn)(window,2,1);
  372.     (*functions->EmbossOn)(window,3,1);
  373.     (*functions->EmbossOn)(window,4,1);
  374.     (*functions->EmbossOn)(window,5,1);
  375.     (*functions->EmbossOn)(window,6,1);
  376.  
  377.  
  378.     for (;;) {
  379.         if (refresh)
  380.         {
  381.  
  382.             (*functions->SelectEmbossed)(window,0,tool->Note);
  383.             (*functions->SelectEmbossed)(window,1,tool->Pitch);
  384.             (*functions->SelectEmbossed)(window,2,tool->MonoAT);
  385.             (*functions->SelectEmbossed)(window,3,tool->PolyAT);
  386.             (*functions->SelectEmbossed)(window,4,tool->CChange);
  387.             (*functions->SelectEmbossed)(window,5,tool->PChange);
  388.             (*functions->SelectEmbossed)(window,6,tool->SysEx);
  389.  
  390.         }
  391.         refresh = 0;
  392.         message = (struct IntuiMessage *) (*functions->GetIntuiMessage)(window);
  393.         class = message->Class;
  394.         code = message->Code;
  395.         gadget = (struct Gadget *) message->IAddress;
  396.         class = (*functions->SystemGadgets)(window,class,gadget,code);
  397.         ReplyMsg((struct Message *)message);
  398.         if (class == CLOSEWINDOW) break;
  399.         else if (class == GADGETDOWN) {
  400.  
  401.  
  402.             }
  403.  
  404.  
  405.         else if (class == GADGETUP)  {
  406.  
  407.             switch(gadget->GadgetID)
  408.             {
  409.                       case 0:
  410.                       tool->Note = !tool->Note;
  411.                       refresh = 1;
  412.                       break;
  413.  
  414.                       case 1:
  415.                       tool->Pitch = !tool->Pitch;
  416.                       refresh = 1;
  417.                       break;
  418.  
  419.                       case 2:
  420.                       tool->MonoAT = !tool->MonoAT;
  421.                       refresh = 1;
  422.                       break;
  423.  
  424.                       case 3:
  425.                       tool->PolyAT = !tool->PolyAT;
  426.                       refresh = 1;
  427.                       break;
  428.  
  429.                       case 4:
  430.                       tool->CChange = !tool->CChange;
  431.                       refresh = 1;
  432.                       break;
  433.  
  434.                       case 5:
  435.                       tool->PChange = !tool->PChange;
  436.                       refresh = 1;
  437.                       break;
  438.  
  439.                       case 6:
  440.                       tool->SysEx = !tool->SysEx;
  441.                       refresh = 1;
  442.                       break;
  443.  
  444.                       default:
  445.                         break;
  446.  
  447.             }
  448.        }
  449.     }
  450.  
  451.     (*functions->EmbossOff)(window,0);
  452.     (*functions->EmbossOff)(window,1);
  453.     (*functions->EmbossOff)(window,2);
  454.     (*functions->EmbossOff)(window,3);
  455.     (*functions->EmbossOff)(window,4);
  456.     (*functions->EmbossOff)(window,5);
  457.     (*functions->EmbossOff)(window,6);
  458.  
  459.     tool->tool.window = 0;
  460.     tool->tool.left = window->LeftEdge;
  461.     tool->tool.top = window->TopEdge;
  462.     tool->tool.touched = TOUCH_INIT | TOUCH_EDIT;
  463.     (*functions->FlashyCloseWindow)(window);
  464.     (*functions->DeleteNewWindow)(newwindow);
  465. }
  466.  
  467. extern printf();
  468.  
  469. struct Event *processeventcode(struct Event *event)
  470. {
  471.     UBYTE data[10];
  472.     UBYTE channel;
  473.     struct OutTool *tool = (struct OutTool *) event->tool;
  474.     BOOL skip = FALSE;
  475.  
  476.     if(!serial)
  477.     {
  478.         if((openserial(name, unit)) != 3) serial = FALSE;
  479.         else serial = TRUE;
  480.     }
  481.  
  482.     channel = (UBYTE)tool->tool.track->channelout;
  483.  
  484.     if (!tool->tool.touched) {
  485.         tool->tool.touched = TOUCH_INIT;
  486.                     tool->Note= TRUE;
  487.                     tool->Pitch= TRUE;
  488.                     tool->MonoAT= TRUE;
  489.                     tool->PolyAT= TRUE;
  490.                     tool->CChange= TRUE;
  491.                     tool->PChange= TRUE;
  492.                     tool->SysEx= FALSE;
  493.     }                                    
  494.  
  495.     switch (event->status)
  496.     {
  497.         case MIDI_NOTEON:
  498.         if(tool->Note)
  499.         {
  500.             data[0] = 0x90|channel;
  501.             data[1] = event->byte1;
  502.             data[2] = event->byte2;
  503.             SerialIO->IOSer.io_Length=3;
  504.             SerialIO->IOSer.io_Data=(APTR)data;
  505.             SerialIO->IOSer.io_Command=CMD_WRITE;
  506.         }
  507.         break;
  508.  
  509.         case MIDI_NOTEOFF:
  510.         if(tool->Note)
  511.         {
  512.             data[0] = 0x80|channel;
  513.             data[1] = event->byte1;
  514.             data[2] = event->byte2;
  515.             SerialIO->IOSer.io_Length=3;
  516.             SerialIO->IOSer.io_Data=(APTR)data;
  517.             SerialIO->IOSer.io_Command=CMD_WRITE;
  518.         }
  519.         break;
  520.  
  521.         case MIDI_PTOUCH:
  522.         if(tool->PolyAT)
  523.         {
  524.             data[0] = 0xA0|channel;
  525.             data[1] = event->byte1;
  526.             data[2] = event->byte2;
  527.             SerialIO->IOSer.io_Length=3;
  528.             SerialIO->IOSer.io_Data=(APTR)data;
  529.             SerialIO->IOSer.io_Command=CMD_WRITE;
  530.         }
  531.         break;
  532.  
  533.         case MIDI_MTOUCH:
  534.         if(tool->MonoAT)
  535.         {
  536.             data[0] = 0xD0|channel;
  537.             data[1] = event->byte1;
  538.             SerialIO->IOSer.io_Length=2;
  539.             SerialIO->IOSer.io_Data=(APTR)data;
  540.             SerialIO->IOSer.io_Command=CMD_WRITE;
  541.         }
  542.         break;
  543.  
  544.         case MIDI_PCHANGE:
  545.         if(tool->PChange)
  546.         {
  547.             data[0] = 0xC0|channel;
  548.             data[1] = event->byte1;
  549.             SerialIO->IOSer.io_Length=2;
  550.             SerialIO->IOSer.io_Data=(APTR)data;
  551.             SerialIO->IOSer.io_Command=CMD_WRITE;
  552.         }
  553.         break;
  554.  
  555.         case MIDI_PBEND:
  556.         if(tool->Pitch)
  557.         {
  558.             data[0] = 0xE0|channel;
  559.             data[1] = event->byte1;
  560.             data[2] = event->byte2;
  561.             SerialIO->IOSer.io_Length=3;
  562.             SerialIO->IOSer.io_Data=(APTR)data;
  563.             SerialIO->IOSer.io_Command=CMD_WRITE;
  564.         }
  565.         break;
  566.  
  567.         case MIDI_CCHANGE:
  568.             if(tool->CChange)
  569.             {
  570.                 data[0] = 0xB0|channel;
  571.                 data[1] = (UBYTE)event->byte1;
  572.                 data[2] = (UBYTE)event->byte2;
  573.                 SerialIO->IOSer.io_Length=3;
  574.                 SerialIO->IOSer.io_Data=(APTR)data;
  575.                 SerialIO->IOSer.io_Command=CMD_WRITE;
  576.             }
  577.         break;
  578.  
  579.         case MIDI_SYSX:
  580.         if(tool->SysEx)
  581.         {
  582.             struct StringEvent *se= (struct StringEvent *) event;
  583.  
  584.             sendsysex(se->string->string, se->string->length);
  585.         }
  586.         break;
  587.  
  588.         case MIDI_MTC:
  589.         data[0] = 0xF1;
  590.         SerialIO->IOSer.io_Length=1;
  591.         SerialIO->IOSer.io_Data=(APTR)data;
  592.         SerialIO->IOSer.io_Command=CMD_WRITE;
  593.         break;
  594.  
  595.         case MIDI_CLOCK:
  596.         data[0] = 0xF8;
  597.         SerialIO->IOSer.io_Length=1;
  598.         SerialIO->IOSer.io_Data=(APTR)data;
  599.         SerialIO->IOSer.io_Command=CMD_WRITE;
  600.         break;
  601.  
  602.         case MIDI_SONGPP:
  603.         data[0] = 0xF2;
  604.         data[1] = event->byte1;
  605.         data[2] = event->byte2;
  606.         SerialIO->IOSer.io_Length=3;
  607.         SerialIO->IOSer.io_Data=(APTR)data;
  608.         SerialIO->IOSer.io_Command=CMD_WRITE;
  609.         break;
  610.  
  611.         case MIDI_SONGS:
  612.         data[0] = 0xF3;
  613.         SerialIO->IOSer.io_Length=1;
  614.         SerialIO->IOSer.io_Data=(APTR)data;
  615.         SerialIO->IOSer.io_Command=CMD_WRITE;
  616.         break;
  617.  
  618.         case MIDI_START:
  619.         data[0] = 0xFA;
  620.         SerialIO->IOSer.io_Length=1;
  621.         SerialIO->IOSer.io_Data=(APTR)data;
  622.         SerialIO->IOSer.io_Command=CMD_WRITE;
  623.         break;
  624.  
  625.         case MIDI_STOP:
  626.         data[0] = 0xFC;
  627.         SerialIO->IOSer.io_Length=1;
  628.         SerialIO->IOSer.io_Data=(APTR)data;
  629.         SerialIO->IOSer.io_Command=CMD_WRITE;
  630.         break;
  631.  
  632.         case MIDI_CONTINUE:
  633.         data[0] = 0xFB;
  634.         SerialIO->IOSer.io_Length=1;
  635.         SerialIO->IOSer.io_Data=(APTR)data;
  636.         SerialIO->IOSer.io_Command=CMD_WRITE;
  637.         break;
  638.  
  639.         case MIDI_SENSE:
  640.         data[0] = 0xFE;
  641.         SerialIO->IOSer.io_Length=1;
  642.         SerialIO->IOSer.io_Data=(APTR)data;
  643.         SerialIO->IOSer.io_Command=CMD_WRITE;
  644.         break;
  645.  
  646.         default:
  647.         break;
  648.     }
  649.  
  650.         if(serial)DoIO((struct IORequest *)SerialIO);
  651.  
  652. (*functions->freeevent)(event);
  653. return(0);
  654. }
  655.  
  656. static struct ToolMaster master;
  657.  
  658.  
  659. void   removetool(struct OutTool *tool)
  660. {
  661.     closeserial();
  662. }
  663.  
  664. struct ToolMaster *inittoolmaster(void)
  665. {
  666.     BPTR prefs;
  667.     int i;
  668.  
  669.     memset((char *)&master,0,sizeof(struct ToolMaster));
  670.     master.toolsize = sizeof(struct OutTool);
  671.     master.toolid = ID_MOU;
  672.     master.edittool = edittoolcode;
  673.     master.deletetool = deletetool;
  674.     master.removetool = removetool;
  675.     master.image = &outtoolimage;
  676.     strcpy(master.name,"New MIDI Out 1");
  677.     master.processevent = processeventcode;
  678.     master.tooltype = TOOL_OUTPUT|TOOL_ONTIME|TOOL_MIDI;
  679.  
  680.     prefs = Open("envarc:NewMidiOut1.prefs",MODE_OLDFILE);
  681.  
  682.     if(prefs)
  683.     {
  684.         FGets(prefs,name,299);
  685.         for(i=0; i<299; i++)
  686.         {
  687.             if(isspace(name[i])) break;
  688.         }
  689.  
  690.         name[i] = NULL;
  691.  
  692.         FGets(prefs,un,299);
  693.         for(i=0; i<299; i++)
  694.         {
  695.             if(isspace(un[i])) break;
  696.         }
  697.  
  698.         un[i] = NULL;
  699.         unit = atoi(un);
  700.         Close(prefs);
  701.     }
  702.     return(&master);
  703. }
  704.  
  705. int openserial(char *devicename, int unit)
  706. {
  707.         if (SerialMP=CreateMsgPort())
  708.         {
  709.             if (SerialIO=(struct IOExtSer *)CreateExtIO(SerialMP,sizeof(struct IOExtSer)) )
  710.             {
  711.                 SerialIO->io_SerFlags|= SERF_SHARED;
  712.  
  713.                 if (OpenDevice(devicename,unit,(struct IORequest *)SerialIO,0))
  714.                 {
  715.                     return 0;
  716.                 }
  717.                 else
  718.                 {
  719.                     SerialIO->IOSer.io_Command  = SDCMD_QUERY;
  720.                     DoIO((struct IORequest *)SerialIO);             /* execute query */
  721.  
  722.                     SerialIO->IOSer.io_Command  = SDCMD_SETPARAMS;
  723.                     SerialIO->io_SerFlags &= ~SERF_PARTY_ON;
  724.                     SerialIO->io_SerFlags|=(SERF_RAD_BOOGIE|SERF_XDISABLED);
  725.                     SerialIO->io_Baud = 31250;
  726.                     DoIO((struct IORequest *)SerialIO);
  727.  
  728.                 }
  729.             }
  730.             else return 1;
  731.         }
  732.         else return 2;
  733.  
  734. return 3;
  735. }
  736.  
  737. void closeserial(void)
  738. {
  739.     if (SerialIO)
  740.     {
  741.         if (!(CheckIO(SerialIO)))
  742.         {
  743.             AbortIO((struct IORequest *)SerialIO); 
  744.         }                                     
  745.         WaitIO((struct IORequest *)SerialIO);
  746.  
  747.         CloseDevice((struct IORequest *)SerialIO);
  748.         DeleteExtIO((struct IORequest *)SerialIO);
  749.         DeletePort(SerialMP);
  750.     }
  751. }
  752.  
  753.  
  754. static void deletetool(struct OutTool *copy)
  755. {
  756.   functions->myfree(copy, sizeof(struct OutTool));
  757. }
  758.  
  759.